import fs from 'node:fs'
import path from 'node:path'
import { fileURLToPath } from 'node:url'
import { app } from 'electron'
import log from '../logger'

export interface AliCloudVoiceConfigFile {
  description: string
  note: string
  version: string
  config: {
    accessKeyId: string
    accessKeySecret: string
    endpoint: string
    calledShowNumber: string
    defaultPlayTimes: number
    templates: {
      wakeup: string
      test: string
    }
  }
  setup: {
    instructions: string[]
    security: string[]
  }
}

export interface AliCloudVoiceConfig {
  accessKeyId: string
  accessKeySecret: string
  endpoint?: string
  calledShowNumber?: string
  defaultPlayTimes?: number
  templates?: {
    wakeup: string
    test: string
  }
}

export class AliCloudConfigManager {
  private static instance: AliCloudConfigManager
  private configPath: string
  private config: AliCloudVoiceConfig | null = null
  private configLoaded = false

  private constructor() {
    // 获取配置文件路径，检查多个可能的位置
    this.configPath = this.findConfigPath()
    log.info(`[配置管理] 配置文件路径: ${this.configPath}`)
  }

  private findConfigPath(): string {
    // 在 ES modules 中获取当前文件目录
    const __filename = fileURLToPath(import.meta.url)
    const __dirname = path.dirname(__filename)
    
    const possiblePaths = [
      // 开发环境路径
      path.join(process.cwd(), 'config', 'alicloud-voice.json'),
      // 相对于当前模块的路径
      path.join(__dirname, '..', '..', '..', 'config', 'alicloud-voice.json'),
      // 用户数据目录（优先级最高，用于生产环境）
      path.join(app.getPath('userData'), 'config', 'alicloud-voice.json'),
    ]

    // 检查每个可能的路径
    for (const configPath of possiblePaths) {
      if (fs.existsSync(configPath)) {
        log.info(`[配置管理] 找到配置文件: ${configPath}`)
        return configPath
      }
    }

    // 如果都不存在，使用用户数据目录作为默认路径（生产环境）
    const userDataPath = possiblePaths[2]
    log.warn(`[配置管理] 配置文件不存在，将使用用户数据目录: ${userDataPath}`)
    
    // 尝试从模板创建配置文件
    this.copyTemplateIfNotExists(userDataPath)
    
    return userDataPath
  }

  /**
   * 从模板文件复制配置到用户数据目录
   */
  private copyTemplateIfNotExists(targetPath: string): void {
    try {
      // 如果目标文件已存在，不覆盖
      if (fs.existsSync(targetPath)) {
        return
      }

      // 查找模板文件的可能位置
      const __filename = fileURLToPath(import.meta.url)
      const __dirname = path.dirname(__filename)
      
      const templatePaths = [
        // 开发环境
        path.join(process.cwd(), 'config', 'alicloud-voice.template.json'),
        // 打包后的资源目录
        path.join(process.resourcesPath, 'config', 'alicloud-voice.template.json'),
        // 相对于当前模块
        path.join(__dirname, '..', '..', '..', 'config', 'alicloud-voice.template.json'),
      ]

      let templatePath: string | null = null
      for (const tPath of templatePaths) {
        if (fs.existsSync(tPath)) {
          templatePath = tPath
          break
        }
      }

      if (!templatePath) {
        log.warn('[配置管理] 未找到配置模板文件')
        return
      }

      // 确保目标目录存在
      const targetDir = path.dirname(targetPath)
      if (!fs.existsSync(targetDir)) {
        fs.mkdirSync(targetDir, { recursive: true })
        log.info(`[配置管理] 创建配置目录: ${targetDir}`)
      }

      // 复制模板文件
      fs.copyFileSync(templatePath, targetPath)
      log.info(`[配置管理] 已从模板创建配置文件: ${targetPath}`)
      log.info('[配置管理] 请编辑此文件并填入您的阿里云 AccessKey 信息')
    } catch (error: any) {
      log.error(`[配置管理] 复制模板文件失败: ${error.message}`)
    }
  }

  public static getInstance(): AliCloudConfigManager {
    if (!AliCloudConfigManager.instance) {
      AliCloudConfigManager.instance = new AliCloudConfigManager()
    }
    return AliCloudConfigManager.instance
  }

  /**
   * 加载配置文件
   */
  public loadConfig(): { success: boolean; error?: string; config?: AliCloudVoiceConfig } {
    try {
      log.info('[配置管理] 开始加载阿里云语音服务配置...')

      // 检查配置文件是否存在
      if (!fs.existsSync(this.configPath)) {
        const error = `配置文件不存在: ${this.configPath}`
        log.error(`[配置管理] ${error}`)
        return {
          success: false,
          error: `配置文件不存在，请先配置 config/alicloud-voice.json 文件`
        }
      }

      // 读取配置文件
      const configContent = fs.readFileSync(this.configPath, 'utf-8')
      const configData: AliCloudVoiceConfigFile = JSON.parse(configContent)

      // 验证配置格式
      if (!configData.config) {
        return {
          success: false,
          error: '配置文件格式错误：缺少 config 字段'
        }
      }

      const { config: rawConfig } = configData

      // 验证必需字段
      if (!rawConfig.accessKeyId || rawConfig.accessKeyId === 'YOUR_ACCESS_KEY_ID') {
        return {
          success: false,
          error: '请在配置文件中设置有效的 AccessKey ID'
        }
      }

      if (!rawConfig.accessKeySecret || rawConfig.accessKeySecret === 'YOUR_ACCESS_KEY_SECRET') {
        return {
          success: false,
          error: '请在配置文件中设置有效的 AccessKey Secret'
        }
      }

      // 构建配置对象
      this.config = {
        accessKeyId: rawConfig.accessKeyId.trim(),
        accessKeySecret: rawConfig.accessKeySecret.trim(),
        endpoint: rawConfig.endpoint || 'dyvmsapi.aliyuncs.com',
        calledShowNumber: rawConfig.calledShowNumber || '4001112222',
        defaultPlayTimes: rawConfig.defaultPlayTimes || 3,
        templates: rawConfig.templates || {
          wakeup: '检测到直播间需要您的注意，请尽快查看直播状态。',
          test: '您正在尝试变更${product}重要信息，验证码${code}，请妥善保管账户信息。'
        }
      }

      this.configLoaded = true
      log.info('[配置管理] 阿里云语音服务配置加载成功')
      
      return {
        success: true,
        config: this.config
      }
    } catch (error: any) {
      const errorMsg = `配置文件解析失败: ${error.message}`
      log.error(`[配置管理] ${errorMsg}`)
      return {
        success: false,
        error: errorMsg
      }
    }
  }

  /**
   * 获取当前配置
   */
  public getConfig(): AliCloudVoiceConfig | null {
    if (!this.configLoaded) {
      const result = this.loadConfig()
      if (!result.success) {
        return null
      }
    }
    return this.config
  }

  /**
   * 重新加载配置
   */
  public reloadConfig(): { success: boolean; error?: string; config?: AliCloudVoiceConfig } {
    this.config = null
    this.configLoaded = false
    return this.loadConfig()
  }

  /**
   * 验证配置文件是否存在且格式正确
   */
  public validateConfig(): { success: boolean; error?: string } {
    const result = this.loadConfig()
    return {
      success: result.success,
      error: result.error
    }
  }

  /**
   * 获取配置文件路径
   */
  public getConfigPath(): string {
    return this.configPath
  }

  /**
   * 检查配置是否已加载且有效
   */
  public isConfigValid(): boolean {
    const config = this.getConfig()
    return !!(config && config.accessKeyId && config.accessKeySecret)
  }

  /**
   * 获取叫醒消息模板
   */
  public getWakeupTemplate(): string {
    const config = this.getConfig()
    return config?.templates?.wakeup || '检测到直播间需要您的注意，请尽快查看直播状态。'
  }

  /**
   * 获取测试消息模板
   */
  public getTestTemplate(): string {
    const config = this.getConfig()
    return config?.templates?.test || '您正在尝试变更${product}重要信息，验证码${code}，请妥善保管账户信息。'
  }
}

// 导出单例实例
export const aliCloudConfigManager = AliCloudConfigManager.getInstance()
